package cn.edu.baiyunu.myapplication.utils

import android.content.ContentResolver
import android.content.ContentValues
import android.content.Context
import android.graphics.Bitmap
import android.media.MediaScannerConnection
import android.net.Uri
import android.os.Build
import android.os.Environment
import android.provider.MediaStore
import android.util.Log
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.File
import java.io.FileOutputStream
import java.io.IOException
import java.io.OutputStream
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale

/**
 * 存储辅助工具类，用于处理图片保存和共享
 */
object StorageHelper {

    private const val TAG = "StorageHelper"
    private const val APP_FOLDER_NAME = "AIPhoto"
    
    /**
     * 为原始图片创建缩略图
     * 
     * @param bitmap 原始位图
     * @param maxWidth 缩略图最大宽度
     * @param maxHeight 缩略图最大高度
     * @return 缩放后的缩略图位图
     */
    fun createThumbnail(bitmap: Bitmap, maxWidth: Int = 200, maxHeight: Int = 200): Bitmap {
        val width = bitmap.width
        val height = bitmap.height
        
        // 计算缩放比例
        val scaleWidth = maxWidth.toFloat() / width
        val scaleHeight = maxHeight.toFloat() / height
        val scale = scaleWidth.coerceAtMost(scaleHeight)
        
        // 如果图片已经小于指定尺寸，不需要缩放
        if (width <= maxWidth && height <= maxHeight) {
            return bitmap.copy(bitmap.config ?: Bitmap.Config.ARGB_8888, true)
        }
        
        // 计算缩放后的尺寸
        val scaledWidth = (width * scale).toInt()
        val scaledHeight = (height * scale).toInt()
        
        // 创建缩略图
        return Bitmap.createScaledBitmap(bitmap, scaledWidth, scaledHeight, true)
    }
    
    /**
     * 保存图片到外部存储
     * 
     * @param context 上下文
     * @param bitmap 要保存的图像
     * @param filename 可选的文件名，如果为null会自动生成
     * @return 保存的文件的Uri，如果保存失败则返回null
     */
    suspend fun saveImageToExternalStorage(
        context: Context, 
        bitmap: Bitmap, 
        filename: String? = null
    ): Uri? = withContext(Dispatchers.IO) {
        try {
            Log.d(TAG, "开始保存图片到外部存储")
            val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(Date())
            val imageFileName = filename ?: "AI_Photo_$timeStamp.jpg"
            
            // 选择图片的保存质量
            val quality = 100  // 可以根据需要调整，范围0-100
            val compressFormat = Bitmap.CompressFormat.JPEG
            
            // 创建缩略图 - 注意：缩略图现在只由ViewModel直接创建并保存在内部存储
            // 不再在此处处理缩略图，避免重复保存到相册
            
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                // Android 10及以上使用MediaStore API保存主图
                Log.d(TAG, "使用MediaStore API (Android 10+)保存主图")
                
                val contentValues = ContentValues().apply {
                    put(MediaStore.MediaColumns.DISPLAY_NAME, imageFileName)
                    put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
                    put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_PICTURES + File.separator + APP_FOLDER_NAME)
                }
                
                val contentResolver: ContentResolver = context.contentResolver
                val imageUri = contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
                
                if (imageUri != null) {
                    contentResolver.openOutputStream(imageUri)?.use { outputStream ->
                        bitmap.compress(compressFormat, quality, outputStream)
                        outputStream.flush()
                        Log.d(TAG, "主图成功保存到: $imageUri")
                        
                        // 返回主图Uri
                        return@withContext imageUri
                    }
                } else {
                    Log.e(TAG, "无法创建MediaStore条目")
                }
            } else {
                // Android 9及以下使用传统File API保存主图
                Log.d(TAG, "使用传统File API (Android 9-)保存主图")
                
                val directory = File(
                    Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
                    APP_FOLDER_NAME
                )
                
                // 确保目录存在
                if (!directory.exists()) {
                    val dirCreated = directory.mkdirs()
                    Log.d(TAG, "创建目录结果: $dirCreated")
                }
                
                val file = File(directory, imageFileName)
                
                try {
                    FileOutputStream(file).use { outputStream ->
                        bitmap.compress(compressFormat, quality, outputStream)
                        outputStream.flush()
                    }
                    
                    // 通知媒体扫描器更新媒体数据库（只更新主图）
                    MediaScannerConnection.scanFile(
                        context, 
                        arrayOf(file.absolutePath), 
                        arrayOf("image/jpeg"), 
                        null
                    )
                    
                    Log.d(TAG, "主图成功保存到: ${file.absolutePath}")
                    return@withContext Uri.fromFile(file)
                } catch (e: IOException) {
                    Log.e(TAG, "文件操作错误: ${e.message}")
                }
            }
            
            return@withContext null
        } catch (e: Exception) {
            Log.e(TAG, "保存图片时出错: ${e.message}", e)
            return@withContext null
        }
    }
    
    /**
     * 检查存储权限并创建必要的目录
     */
    fun ensureStorageDirectoryExists(context: Context): Boolean {
        return try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                // Android 10+不需要创建目录，使用MediaStore会自动创建
                true
            } else {
                val directory = File(
                    Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
                    APP_FOLDER_NAME
                )
                if (!directory.exists()) {
                    val result = directory.mkdirs()
                    Log.d(TAG, "创建存储目录: $result")
                    result
                } else {
                    true
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "确保存储目录存在时出错: ${e.message}")
            false
        }
    }
    
    /**
     * 生成临时文件Uri
     */
    fun createTempImageUri(context: Context): Uri? {
        return try {
            val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(Date())
            val imageFileName = "TEMP_$timeStamp.jpg"
            
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                val contentValues = ContentValues().apply {
                    put(MediaStore.MediaColumns.DISPLAY_NAME, imageFileName)
                    put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
                    put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_PICTURES + File.separator + APP_FOLDER_NAME)
                }
                
                context.contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
            } else {
                val directory = File(
                    context.getExternalFilesDir(Environment.DIRECTORY_PICTURES),
                    APP_FOLDER_NAME
                )
                
                if (!directory.exists()) {
                    directory.mkdirs()
                }
                
                val file = File(directory, imageFileName)
                Uri.fromFile(file)
            }
        } catch (e: Exception) {
            Log.e(TAG, "创建临时图像URI时出错: ${e.message}")
            null
        }
    }
} 